import { WebSocketServer } from 'ws';
import http from 'http';
import os from 'os';

// 配置常量
const MAX_HISTORY_MESSAGE = 50; // 最大历史消息数
const PORT = 3002;

const server = http.createServer();
const wss = new WebSocketServer({ server });

const clients = new Set();       // 存储所有连接的客户端
let messageHistory = [];         // 修改为 let 使能重新赋值

// 广播消息给所有客户端（可排除指定客户端）
function broadcast(message, excludeClient = null) {
  const messageString = JSON.stringify(message);
  clients.forEach(client => {
    if (client !== excludeClient && client.readyState === 1) {
      client.send(messageString);
    }
  });
}

wss.on('connection', (ws) => {
  // 新客户端连接
  clients.add(ws);
  console.log(`新用户连接，当前在线用户数: ${clients.size}`);
  
  // 发送连接确认消息
  ws.send(JSON.stringify({
    type: 'connection_ack',
    message: '连接服务器成功',
    timestamp: Date.now()
  }));

  // 如果有历史消息，发送给新连接的客户端
  if (messageHistory.length > 0) {
    ws.send(JSON.stringify({
      type: 'history_response',
      messages: messageHistory.slice(-MAX_HISTORY_MESSAGE)
    }));
  }

  ws.on('message', (rawMsg) => {
    try {
      const message = JSON.parse(rawMsg.toString());
      
      switch (message.type) {
        case 'history_sync':
          // 合并并去重消息历史 - 使用新变量存储合并结果
          const mergedHistory = [...new Map([
            ...messageHistory.map(m => [`${m.timestamp}_${m.deviceId}`, m]),
            ...message.messages.map(m => [`${m.timestamp}_${m.deviceId}`, m])
          ]).values()]
          // 按时间戳排序并限制数量
          .sort((a, b) => a.timestamp - b.timestamp)
          .slice(-MAX_HISTORY_MESSAGE);
          
          // 清空原数组并添加新数据
          messageHistory.length = 0;
          messageHistory.push(...mergedHistory);
          break;
          
        case 'user_update':
          // 更新用户信息 - 直接修改数组元素
          messageHistory.forEach(msg => {
            if (msg.deviceId === message.deviceId) {
              msg.user = message.newName;
            }
          });
          
          // 广播用户更新信息
          broadcast({
            type: 'user_updated',
            deviceId: message.deviceId,
            newName: message.newName,
            timestamp: Date.now()
          });
          break;
          
        default:
          // 普通消息处理 - 直接添加到数组
          const validatedMessage = {
            ...message,
            timestamp: message.timestamp || Date.now()
          };
          
          messageHistory.push(validatedMessage);
          if (messageHistory.length > MAX_HISTORY_MESSAGE) {
            messageHistory.shift();
          }
          
          broadcast(validatedMessage);
      }
    } catch (error) {
      console.error('消息处理出错:', error);
      ws.send(JSON.stringify({
        type: 'error',
        message: '消息格式无效'
      }));
    }
  });

  ws.on('close', () => {
    clients.delete(ws);
    console.log(`用户断开连接，剩余在线用户数: ${clients.size}`);
  });

  ws.on('error', (error) => {
    console.error('WebSocket错误:', error);
    clients.delete(ws);
  });
});

// 获取本机网络IP地址
function getNetworkIp() {
  const interfaces = os.networkInterfaces();
  for (const name of Object.keys(interfaces)) {
    for (const iface of interfaces[name]) {
      if (iface.family === 'IPv4' && !iface.internal) {
        return iface.address;
      }
    }
  }
  return 'localhost';
}

server.listen(PORT, '0.0.0.0', () => {
  console.log(`✅ 服务器已启动，监听端口: ${PORT}`);
  console.log(`本地访问: ws://localhost:${PORT}`);
  console.log(`网络访问: ws://${getNetworkIp()}:${PORT}`);
});
